home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / h / vd2 / system / vectors_float.h < prev    next >
Encoding:
C/C++ Source or Header  |  2007-01-07  |  7.6 KB  |  208 lines
  1. class vdfloat2 {
  2. public:
  3.     typedef vdfloat2 self_type;
  4.     typedef float value_type;
  5.  
  6.     void set(float x2, float y2) { x=x2; y=y2; }
  7.  
  8.     float&            operator[](int k)                    { return v[k]; }
  9.     const float&    operator[](int k) const                { return v[k]; }
  10.  
  11.     float        lensq() const                            { return x*x + y*y; }
  12.  
  13.     self_type    operator-() const                        { self_type a = {-x, -y}; return a; }
  14.  
  15.     self_type    operator+(const self_type& r) const        { self_type a = {x+r.x, y+r.y}; return a; }
  16.     self_type    operator-(const self_type& r) const        { self_type a = {x-r.x, y-r.y}; return a; }
  17.  
  18.     self_type&    operator+=(const self_type& r)            { x+=r.x; y+=r.y; return *this; }
  19.     self_type&    operator-=(const self_type& r)            { x-=r.x; y-=r.y; return *this; }
  20.  
  21.     self_type    operator*(const float s) const            { self_type a = {x*s, x*s}; return a; }
  22.     self_type&    operator*=(const float s)                { x*=s; y*=s; return *this; }
  23.  
  24.     self_type    operator/(const float s) const            { const float inv(float(1)/s); self_type a = {x*inv, y*inv}; return a; }
  25.     self_type&    operator/=(const float s)                { const float inv(float(1)/s); x*=inv; y*=inv; return *this; }
  26.  
  27.     self_type    operator*(const self_type& r) const        { self_type a = {x*r.x, y*r.y}; return a; }
  28.     self_type&    operator*=(const self_type& r)            { x*=r.x; y*=r.y; return *this; }
  29.  
  30.     self_type    operator/(const self_type& r) const        { self_type a = {x/r.x, y/r.y}; return a; }
  31.     self_type&    operator/=(const self_type& r)            { x/=r.x; y/=r.y; return *this; }
  32.  
  33.     union {
  34.         struct {
  35.             float x;
  36.             float y;
  37.         };
  38.         float v[2];
  39.     };
  40. };
  41.  
  42. VDFORCEINLINE vdfloat2 operator*(const float s, const vdfloat2& v) { return v*s; }
  43.  
  44. ///////////////////////////////////////////////////////////////////////////
  45.  
  46. class vdfloat3 {
  47. public:
  48.     typedef vdfloat3 self_type;
  49.     typedef float value_type;
  50.  
  51.     void set(float x2, float y2, float z2) { x=x2; y=y2; z=z2; }
  52.  
  53.     float&            operator[](int k)                    { return v[k]; }
  54.     const float&    operator[](int k) const                { return v[k]; }
  55.  
  56.     float        lensq() const                            { return x*x + y*y + z*z; }
  57.  
  58.     vdfloat2    project() const                            { const float inv(float(1)/z); const vdfloat2 a = {x*inv, y*inv}; return a; }
  59.     vdfloat2    as2d() const                            { const vdfloat2 a = {x, y}; return a; }
  60.  
  61.     self_type    operator-() const                        { const self_type a = {-x, -y, -z}; return a; }
  62.  
  63.     self_type    operator+(const self_type& r) const        { const self_type a = {x+r.x, y+r.y, z+r.z}; return a; }
  64.     self_type    operator-(const self_type& r) const        { const self_type a = {x-r.x, y-r.y, z-r.z}; return a; }
  65.  
  66.     self_type&    operator+=(const self_type& r)            { x+=r.x; y+=r.y; z+=r.z; return *this; }
  67.     self_type&    operator-=(const self_type& r)            { x-=r.x; y-=r.y; z-=r.z; return *this; }
  68.  
  69.     self_type    operator*(const float s) const            { const self_type a = {x*s, y*s, z*s}; return a; }
  70.     self_type&    operator*=(const float s)                { x*=s; y*=s; z*=s; return *this; }
  71.  
  72.     self_type    operator/(const float s) const            { const float inv(float(1)/s); const self_type a = {x*inv, y*inv, z*inv}; return a; }
  73.     self_type&    operator/=(const float s)                { const float inv(float(1)/s); x*=inv; y*=inv; z*=inv; return *this; }
  74.  
  75.     self_type    operator*(const self_type& r) const        { self_type a = {x*r.x, y*r.y, z*r.z}; return a; }
  76.     self_type&    operator*=(const self_type& r)            { x*=r.x; y*=r.y; z*=r.z; return *this; }
  77.  
  78.     self_type    operator/(const self_type& r) const        { self_type a = {x/r.x, y/r.y, z/r.z}; return a; }
  79.     self_type&    operator/=(const self_type& r)            { x/=r.x; y/=r.y; z/=r.z; return *this; }
  80.  
  81.     union {
  82.         struct {
  83.             float x;
  84.             float y;
  85.             float z;
  86.         };
  87.         float v[3];
  88.     };
  89. };
  90.  
  91. VDFORCEINLINE vdfloat3 operator*(const float s, const vdfloat3& v) { return v*s; }
  92.  
  93. ///////////////////////////////////////////////////////////////////////////
  94.  
  95. class vdfloat4 {
  96. public:
  97.     typedef vdfloat4 self_type;
  98.     typedef float value_type;
  99.  
  100.     void setzero() { x=y=z=w = 0; }
  101.     void set(float x2, float y2, float z2, float w2) { x=x2; y=y2; z=z2; w=w2; }
  102.  
  103.     float&            operator[](int i) { return v[i]; }
  104.     const float&    operator[](int i) const { return v[i]; }
  105.  
  106.     float        lensq() const                            { return x*x + y*y + z*z + w*w; }
  107.  
  108.     vdfloat3    project() const                            { const float inv(float(1)/w); const vdfloat3 a = {x*inv, y*inv, z*inv}; return a; }
  109.  
  110.     self_type    operator-() const                        { const self_type a = {-x, -y, -z, -w}; return a; }
  111.  
  112.     self_type    operator+(const self_type& r) const        { const self_type a = {x+r.x, y+r.y, z+r.z, w+r.w}; return a; }
  113.     self_type    operator-(const self_type& r) const        { const self_type a = {x-r.x, y-r.y, z-r.z, w-r.w}; return a; }
  114.  
  115.     self_type&    operator+=(const self_type& r)            { x+=r.x; y+=r.y; z+=r.z; w+=r.w; return *this; }
  116.     self_type&    operator-=(const self_type& r)            { x-=r.x; y-=r.y; z-=r.z; w-=r.w; return *this; }
  117.  
  118.     self_type    operator*(const float factor) const        { const self_type a = {x*factor, y*factor, z*factor, w*factor}; return a; }
  119.     self_type    operator/(const float factor) const        { const float inv(float(1) / factor); const self_type a = {x*inv, y*inv, z*inv, w*inv}; return a; }
  120.  
  121.     self_type&    operator*=(const float factor)            { x *= factor; y *= factor; z *= factor; w *= factor; return *this; }
  122.     self_type&    operator/=(const float factor)            { const float inv(float(1) / factor); x *= inv; y *= inv; z *= inv; w *= inv; return *this; }
  123.  
  124.     self_type    operator*(const self_type& r) const        { self_type a = {x*r.x, y*r.y, z*r.z, w*r.w}; return a; }
  125.     self_type&    operator*=(const self_type& r)            { x*=r.x; y*=r.y; z*=r.z; w*=r.w; return *this; }
  126.  
  127.     self_type    operator/(const self_type& r) const        { self_type a = {x/r.x, y/r.y, z/r.z, w*r.w}; return a; }
  128.     self_type&    operator/=(const self_type& r)            { x/=r.x; y/=r.y; z/=r.z; w/=r.w; return *this; }
  129.  
  130.     union {
  131.         struct {
  132.             float x;
  133.             float y;
  134.             float z;
  135.             float w;
  136.         };
  137.         float v[4];
  138.     };
  139. };
  140.  
  141. VDFORCEINLINE vdfloat4 operator*(const float s, const vdfloat4& v) { return v*s; }
  142.  
  143. ///////////////////////////////////////////////////////////////////////////
  144.  
  145. class vdfloat2c : public vdfloat2 {
  146. public:
  147.     VDFORCEINLINE vdfloat2c(float x2, float y2) {x=x2; y=y2;}
  148.     VDFORCEINLINE vdfloat2c(const float src[2]) {x=src[0]; y=src[1];}
  149. };
  150.  
  151. class vdfloat3c : public vdfloat3 {
  152. public:
  153.     VDFORCEINLINE vdfloat3c(float x2, float y2, float z2) { x=x2; y=y2; z=z2; }
  154.     VDFORCEINLINE vdfloat3c(const float src[3]) { x=src[0]; y=src[1]; z=src[2]; }
  155. };
  156.  
  157. class vdfloat4c : public vdfloat4 {
  158. public:
  159.     VDFORCEINLINE vdfloat4c(float x2, float y2, float z2, float w2) { x=x2; y=y2; z=z2; w=w2; }
  160.     VDFORCEINLINE vdfloat4c(const float src[4]) { x=src[0]; y=src[1]; z=src[2]; w=src[3]; }
  161. };
  162.  
  163.  
  164. ///////////////////////////////////////////////////////////////////////////
  165.  
  166. namespace nsVDMath {
  167.     VDFORCEINLINE float length(const vdfloat2& a) {
  168.         return sqrtf(a.x*a.x + a.y*a.y);
  169.     }
  170.  
  171.     VDFORCEINLINE float length(const vdfloat3& a) {
  172.         return sqrtf(a.x*a.x + a.y*a.y + a.z*a.z);
  173.     }
  174.  
  175.     VDFORCEINLINE float length(const vdfloat4& a) {
  176.         return sqrtf(a.x*a.x + a.y*a.y + a.z*a.z + a.w*a.w);
  177.     }
  178.  
  179.     VDFORCEINLINE vdfloat2 normalize(const vdfloat2& a) {
  180.         return a / length(a);
  181.     }
  182.  
  183.     VDFORCEINLINE vdfloat3 normalize(const vdfloat3& a) {
  184.         return a / length(a);
  185.     }
  186.  
  187.     VDFORCEINLINE vdfloat4 normalize(const vdfloat4& a) {
  188.         return a / length(a);
  189.     }
  190.  
  191.     VDFORCEINLINE float dot(const vdfloat2& a, const vdfloat2& b) {
  192.         return a.x*b.x + a.y*b.y;
  193.     }
  194.  
  195.     VDFORCEINLINE float dot(const vdfloat3& a, const vdfloat3& b) {
  196.         return a.x*b.x + a.y*b.y + a.z*b.z;
  197.     }
  198.  
  199.     VDFORCEINLINE float dot(const vdfloat4& a, const vdfloat4& b) {
  200.         return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
  201.     }
  202.  
  203.     VDFORCEINLINE vdfloat3 cross(const vdfloat3& a, const vdfloat3& b) {
  204.         const vdfloat3 r = {a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x};
  205.         return r;
  206.     }
  207. };
  208.